An AgentSpeak meta-interpreter and its applications

A meta-interpreter for a language can provide an easy way of experimenting with modifications or extensions to a language. We give a meta-interpreter for the AgentSpeak language, prove its correctness, and show how the meta-interpreter can be used to extend the AgentSpeak language and to add features to the implementation

Making logic programs reactive

Logic programming languages based on linear logic have been of recent interest, particularly as such languages provide a logical basis for programs which execute within a dynamic environment. Most of these languages are implemented using standard resolution or backward-chaining techniques. However, there are applications for which the use of forward-chaining techniques within a dynamic environment are appropriate, such as genetic algorithms, active databases and agent-based systems, and for which it is difficult or impossible to specify an appropriate goal in advance. In this paper we discuss the foundations for a forward-chaining approach (or in logic programming parlance, a bottom-up approach) to the execution of linear logic programs, which thus provides forward-chaining within a dynamic environment. In this way it is possible not only to execute programs in a forward-chaining manner, but also to combine forward- and backward-chaining execution. We describe and discuss the appropriate inference rules for such a system, the formal results about such rules, the role of search strategies, and applications

Prometheus design tool

The Prometheus Design Tool (PDT) supports the structured design of intelligent agent systems. It supports the Prometheus methodology, but can also be used more generally. This paper outlines the tool and some of its many features

Simplifying the development of intelligent agents

Intelligent agents is a powerful Artificial Intelligence technology which shows considerable promise as a new paradigm for mainstream software development. However, despite their promise, intelligent agents are still scarce in the market place. A key reason for this is that developing intelligent agent software requires significant training and skill: a typical developer or undergraduate struggles to develop good agent systems using the Belief Desire Intention (BDI) model (or similar models). This paper identifies the concept set which we have found to be important in developing intelligent agent systems and the relationships between these concepts. This concept set was developed with the intention of being clearer, simpler, and easier to use than current approaches.We also describe briefly a (very simplified) example from one of the projects we have worked on (RoboRescue), illustrating the way in which these concepts are important in designing and developing intelligent software agents

AUML protocols and code generation in the Prometheus design tool

Prometheus is an agent-oriented software engineering methodology. The Prometheus Design Tool (PDT) is a software tool that supports a designer who is using the Prometheus methodology. PDT has recently been extended with two significant new features: support for Agent UML interaction protocols, and code generation

An exploration of bugs and debugging in multi-agent systems

Debugging multi-agent systems, which are concurrent, distributed, and consist of complex components, is difficult, yet crucial. In earlier work we have proposed mechanisms whereby protocol specifications available from the design process can be used for monitoring the execution of the multi-agent system they describe. Protocol specifications can be used at run-time for reporting any discrepancies in interactions compared to that which was specified. In this paper we describe and categorise a range of bugs found in actual multi-agent systems developed by students in an Agent Oriented Programming and Design class. We then indicate how these bugs manifest to the debugging agent and what information it is able to provide to the user to assist in locating and diagnosing the problem

Adding debugging support to the Prometheus methodology

This paper describes a debugger which uses the design artifacts of the Prometheus agent-oriented software engineering methodology to alert the developer testing the system, that a specification has been violated. Detailed information is provided regarding the error which can help the developer in locating its source. Interaction protocols specified during design, are converted to executable Petri net representations. The system can then be monitored at run time to identify situations which do not conform to specified protocols. A process for monitoring aspects of plan selection is also described. The paper then describes the Prometheus Design Tool, developed to support the Prometheus methodology, and presents a vision of an integrated development environment providing full life cycle support for the development of agent systems. The initial part of the paper provides a detailed summary of the Prometheus methodology and the artifacts on which the debugger is based

Detecting and avoiding interference between goals in intelligent agents

Pro-active agents typically have multiple simultaneous goals. These may interact with each other both positively and negatively. In this paper we provide a mechanism allowing agents to detect and avoid a particular kind of negative interaction where the effects of one goal undo conditions that must be protected for successful pursuit of another goal. In order to detect such interactions we maintain summary information about the definite and potential conditional requirements and resulting effects of goals and their associated plans. We use these summaries to guard protected conditions by scheduling the execution of goals and plan steps. The algorithms and data structures developed allow agents to act rationally instead of blindly pursuing goals that will conflict

Design options for subscription managers

An important issue in open agent systems such as the Internet is the discovery of service providers by potential consumers (requesters). This paper is concerned with services that involve the ongoing provision of up-to-date information to requesters. We explore three separate issues: subscription to an information provider for ongoing provision of information; monitoring for new information providers; and maintaining awareness of when providers disappear from the system. We explore several models for how this functionality may best be provided, with emphasis on the ways in which certain choices affect the overall system; and provide an analysis of preferred design options for environments with different characteristics

Designing institutional multi-agent systems

The vision of agents working together on the Internet, in virtual organizations, is one that is increasingly common. However, one of the issues is the regulation of the participating agents and their behaviour. A substantial body of work exists that investigates agent societies and agent organizations, including work on electronic institutions, such as Islander and Ameli. However, although such work provides concrete tools for specifying and enacting institutions, there is a lack of clear documented guidance to designers who are using these tools. In this paper we describe a methodology for developing an institutional structure for multi agent systems. This methodology captures the knowledge and experience within the Islander group, and integrates it with the Prometheus methodology. This work was supported by the Australian Research Council under grant LP0453486, in collaboration with Agent Oriented Software. We also thank the Australian Tourism Data Warehouse for use of their tourism content in our agents. Carles Sierra is being supported by the Spanish Web-I(2) project and the ARC Discovery Grant DP0557168